home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok71.lha / AntiLinkVirus / AntiLinkVirus.mod < prev    next >
Text File  |  1993-08-15  |  15KB  |  453 lines
  1. (**************************************************************************
  2.  
  3. :Program.       AntiLinkVirus
  4.  
  5. :Contents.      überprüft (erzeugt beim ersten Mal) eine Checksumme von
  6. :Contents.      dem Programm, an das AntiLinkVirus gelinkt wurde.
  7.  
  8. :Usage.         IMPORT AntiLinkVirus;
  9.  
  10.  
  11. :Copyright.     frei kopierbar und benutzbar. Versionen in anderen Sprachen
  12. :Copyright.     sowie die freie Verwendung auch in kommerziellen Produkten
  13. :Copyright.     (was mich angeht) hiermit gestattet.
  14.  
  15. :Author.        Thomas Ansorge
  16.  
  17. :Address.       Dinkelackerring 55, W-6730 Neustadt, Deutschland
  18.  
  19.  
  20. :Language.      Modula-2
  21.  
  22. :Translator.    M2Amiga V4.0 (deutsch)
  23.  
  24. :Imports.       ReqSupport (Frank Zimmermann, AMOK#55, Copyright beachten!)
  25.  
  26. :Imports.       Resident (Thomas Ansorge)
  27.  
  28.  
  29. :Version.       1.0 vom 11. April 1992
  30.  
  31. :History.       1.0 vom 11. April 1992. erste funktionierende Version.
  32.  
  33.  
  34. **************************************************************************)
  35.  
  36.  
  37. (*$ LargeVars := FALSE *)
  38.  
  39.  
  40. IMPLEMENTATION MODULE AntiLinkVirus;
  41.  
  42. FROM Arguments IMPORT GetArg;
  43.  
  44. FROM Arts IMPORT Error, returnVal, Terminate;
  45.  
  46. FROM FileSystem IMPORT Close, File, Lookup, ReadByteBlock, Response,
  47.    WriteByteBlock;
  48.  
  49. IMPORT R;
  50.  
  51. FROM ReqSupport IMPORT TwoGadRequest;
  52.  
  53. FROM Resident IMPORT cliStarted, FindResident;
  54.  
  55. FROM String IMPORT Concat, Copy;
  56.  
  57. FROM SYSTEM IMPORT ADR, ASSEMBLE, CAST;
  58.  
  59. (* --------------------------------------------------------------------- *)
  60.  
  61. CONST EOL = "\n";
  62.  
  63. CONST PosText = "Weiter ...\o";
  64.       NegText = "Abbrechen!\o";
  65.  
  66. CONST ALVText    = "AntiLinkVirus:";
  67.       ChkText    = "Die Checksumme stimmt nicht!";
  68.       FHunkText1 = "Hinter dem Programm ist (mind.) ein zusätzlicher Hunk!";
  69.       FHunkText2 = "Dieser zusätzliche Hunk hat hier nichts zu suchen!";
  70.       KeHunkText = "Ich kann meinen ALV-Hunk nicht finden!";
  71.       LaengeText = "Das Programm ist länger als im Directory eingetragen!";
  72.       LockText   = "Fehler beim Lesen des Programms!\o";
  73.       UHTypText  = "Hier ist ein mir unbekannter Hunktyp.";
  74.  
  75.       KeALVText  = "Bitte verzichten Sie auf AntiLinkVirus.\o";
  76.       LVirusText = "Möglicherweise hat sich ein Link-Virus bei Ihnen eingenistet!\o";
  77.  
  78. CONST FalscheChecksummeFehler = ALVText + EOL + ChkText + EOL + LVirusText;
  79.       FalscheLaengeFehler     = ALVText + EOL + LaengeText + EOL + LVirusText;
  80.       FalscherHunkFehler      = ALVText + EOL + FHunkText1 + EOL + FHunkText2 + EOL +
  81.                                    LVirusText;
  82.       KeinHunk                = ALVText + EOL + KeHunkText + EOL + LVirusText;
  83.       KeinLock                = ALVText + EOL + LockText;
  84.       UnbekannterHunkFehler   = ALVText + EOL + UHTypText + EOL + KeALVText;
  85.  
  86. CONST HunkUnit    = LONGINT (000003E7H);
  87.       HunkName    = LONGINT (000003E8H);
  88.       HunkCode    = LONGINT (000003E9H);
  89.       HunkData    = LONGINT (000003EAH);
  90.       HunkBss     = LONGINT (000003EBH);
  91.       HunkReloc32 = LONGINT (000003ECH);
  92.       HunkReloc16 = LONGINT (000003EDH);
  93.       HunkReloc8  = LONGINT (000003EEH);
  94.       HunkExt     = LONGINT (000003EFH);
  95.       HunkSymbol  = LONGINT (000003F0H);
  96.       HunkDebug   = LONGINT (000003F1H);
  97.       HunkEnde    = LONGINT (000003F2H);
  98.       HunkHeader  = LONGINT (000003F3H);
  99.       HunkUnknown = LONGINT (000003F4H); (* habe ich nirgendwo gefunden *)
  100.       HunkOverlay = LONGINT (000003F5H);
  101.       HunkBreak   = LONGINT (000003F6H);
  102.  
  103.       HunkLaenge = LONGINT (7); (* 7 Langwörter *)
  104.  
  105. CONST ALV  = CAST (LONGINT, "ALV ");
  106.       PIUS = CAST (LONGINT, "PIUS");
  107.  
  108. CONST FilePuffer = 11 * 1024; (* Bytes *)
  109.  
  110. CONST StringMax     = 255;
  111.       LongStringMax = 511;
  112.  
  113. TYPE String     = ARRAY [0..StringMax] OF CHAR;
  114.      LongString = ARRAY [0..LongStringMax] OF CHAR;
  115.  
  116. TYPE HunkCheck = RECORD
  117.         HCode1 : LONGINT;
  118.         HLaenge: LONGINT;
  119.         HName  : LONGINT;
  120.         HAdd   : LONGINT;
  121.         HEor   : LONGINT;
  122.         PLaenge: LONGINT;
  123.         HCode2 : LONGINT;
  124.      END (* RECORD HunkCheck *);
  125.  
  126. (* Name und Pfad dieses Programms *)
  127.  
  128. VAR Datei   : File;
  129.     FileName: String;
  130.     Gelesen : LONGINT;
  131.     Laenge  : INTEGER;
  132.     ReqText : LongString;
  133.  
  134. (* zum Berechnen *)
  135.  
  136. VAR Ladeeinheiten: LONGINT;
  137.     DieserHunk   : LONGINT;
  138.     Langwort     : LONGINT;
  139.  
  140. (* der Check-Hunk *)
  141.  
  142. VAR CheckHunk      : HunkCheck;
  143.     Jungfraeulich  : BOOLEAN;
  144.     MeinHunkGelesen: BOOLEAN;
  145.  
  146. (* diverses *)
  147.  
  148. VAR i,
  149.     j : LONGINT;
  150.  
  151. (* --------------------------------------------------------------------- *)
  152.  
  153. PROCEDURE Check (Gelesen{R.D4}: LONGINT);
  154.  
  155.    (* macht die eigentliche Berechnung *)
  156.  
  157.    (* ------------------------------------------------------------------ *)
  158.  
  159.    BEGIN (* Prozedur Check *)
  160.  
  161.    ASSEMBLE (
  162.       ADD.L D4,CheckHunk.HAdd(A4)
  163.       EOR.L D4,CheckHunk.HEor(A4)
  164.    END); (* ASSEMBLE *)
  165. END Check (* Prozedur *);
  166.  
  167. (* --------------------------------------------------------------------- *)
  168. (* --------------------------------------------------------------------- *)
  169.  
  170. BEGIN (* IMPLEMENTATION MODULE AntiLinkVirus *)
  171.  
  172. alvEvent := ALVEventSet {};
  173.  
  174. Jungfraeulich := TRUE;
  175. MeinHunkGelesen := FALSE;
  176.  
  177. GetArg (0, FileName, Laenge);
  178.  
  179. IF Laenge <= StringMax THEN
  180.    IF NOT (cliStarted AND (FindResident (FileName, FALSE) # NIL)) THEN
  181.       Lookup (Datei, FileName, FilePuffer, FALSE);
  182.  
  183.       IF Datei.res = done THEN
  184.          CheckHunk.HCode1 := HunkName;
  185.          CheckHunk.HLaenge := (SIZE (CheckHunk) DIV 4) - 2;
  186.          CheckHunk.HName := ALV;
  187.          CheckHunk.HAdd := 0;
  188.          CheckHunk.HEor := 0;
  189.          CheckHunk.PLaenge := 0;
  190.          CheckHunk.HCode2 := HunkEnde;
  191.  
  192.          ReadByteBlock (Datei, Langwort);
  193.  
  194.          IF Langwort = HunkHeader THEN
  195.             Concat (FileName, " - ");
  196.  
  197.             Check (Langwort);
  198.             INC (CheckHunk.PLaenge);
  199.  
  200.             ReadByteBlock (Datei, Langwort);
  201.             Check (Langwort);
  202.             INC (CheckHunk.PLaenge);
  203.  
  204.             ReadByteBlock (Datei, Langwort);
  205.             Check (Langwort);
  206.             INC (CheckHunk.PLaenge);
  207.  
  208.             Ladeeinheiten := Langwort;
  209.  
  210.             ReadByteBlock (Datei, Langwort);
  211.             Check (Langwort);
  212.             INC (CheckHunk.PLaenge);
  213.  
  214.             ReadByteBlock (Datei, Langwort);
  215.             Check (Langwort);
  216.             INC (CheckHunk.PLaenge);
  217.  
  218.             FOR i := 1 TO Ladeeinheiten DO
  219.                ReadByteBlock (Datei, Langwort);
  220.                Check (Langwort);
  221.                INC (CheckHunk.PLaenge);
  222.             END (* FOR i *);
  223.  
  224.             (* alle Ladeeinheiten lesen *)
  225.  
  226.             FOR i := 1 TO Ladeeinheiten DO
  227.                REPEAT
  228.                   ReadByteBlock (Datei, Langwort);
  229.                   Check (Langwort);
  230.                   INC (CheckHunk.PLaenge);
  231.  
  232.                   (* die einzelnen Hunks der Ladeeinheiten *)
  233.  
  234.                   CASE Langwort OF
  235.                      |HunkUnit,
  236.                       HunkName,
  237.                       HunkCode,
  238.                       HunkData,
  239.                       HunkHeader:   ReadByteBlock (Datei, Langwort);
  240.                                     Check (Langwort);
  241.                                     INC (CheckHunk.PLaenge);
  242.  
  243.                                     DieserHunk := Langwort;
  244.  
  245.                                     FOR j := 1 TO DieserHunk DO
  246.                                        ReadByteBlock (Datei, Langwort);
  247.                                        Check (Langwort);
  248.                                        INC (CheckHunk.PLaenge);
  249.                                     END (* FOR j *);
  250.  
  251.                      |HunkBss     : ReadByteBlock (Datei, Langwort);
  252.                                     Check (Langwort);
  253.                                     INC (CheckHunk.PLaenge);
  254.  
  255.                      |HunkReloc32,
  256.                       HunkReloc16,
  257.                       HunkReloc8  : REPEAT
  258.                                        ReadByteBlock (Datei, Langwort);
  259.                                        Check (Langwort);
  260.                                        INC (CheckHunk.PLaenge);
  261.  
  262.                                        DieserHunk := Langwort; (* Anzahl d. Offsets *)
  263.  
  264.                                        IF DieserHunk # 0 THEN
  265.                                           ReadByteBlock (Datei, Langwort);
  266.                                           Check (Langwort);
  267.                                           INC (CheckHunk.PLaenge);
  268.  
  269.                                           FOR j := 1 TO DieserHunk DO
  270.                                              ReadByteBlock (Datei, Langwort);
  271.                                              Check (Langwort);
  272.                                              INC (CheckHunk.PLaenge);
  273.                                           END (* FOR j *);
  274.                                        END (* IF DieserHunk *);
  275.                                     UNTIL DieserHunk = 0;
  276.  
  277.                      |HunkEnde    : (* nichts *)
  278.  
  279.                   ELSE (* CASE Langwort *)
  280.                      (* unbekannter Hunk *)
  281.                      Error (ADR (UHTypText), ADR (KeALVText));
  282.                   END (* CASE Langwort *);
  283.                UNTIL Langwort = HunkEnde;
  284.             END (* FOR i *);
  285.  
  286.             (* Ende des eigentlichen Programms. *)
  287.  
  288.             LOOP
  289.                ReadByteBlock (Datei, Langwort);
  290.  
  291.                IF NOT Datei.eof THEN
  292.                   (* das sollte entweder VIRUSCONTROL oder AntiLinkVirus sein *)
  293.  
  294.                   Jungfraeulich := FALSE;
  295.  
  296.                   IF Langwort = HunkName THEN
  297.                      ReadByteBlock (Datei, Langwort);
  298.                      DieserHunk := Langwort;
  299.  
  300.                      ReadByteBlock (Datei, Langwort);
  301.  
  302.                      IF (Langwort = ALV) AND (DieserHunk = CheckHunk.HLaenge) THEN
  303.  
  304.                         (* mein Hunk! *)
  305.  
  306.                         MeinHunkGelesen := TRUE;
  307.  
  308.                         ReadByteBlock (Datei, Langwort);
  309.  
  310.                         IF Langwort # CheckHunk.HAdd THEN
  311.                            INCL (alvEvent, alvCheckSum);
  312.                            
  313.                            Copy (ReqText, FileName);
  314.                            Concat (ReqText, FalscheChecksummeFehler);
  315.  
  316.                            IF TwoGadRequest (ReqText, NIL) = 0 THEN
  317.                               returnVal := 21;
  318.                               Terminate ();
  319.  
  320.                            ELSE (* IF NOT TwoGadRequest *);
  321.                               (* EXIT (* LOOP *); *)
  322.                            END (* IF NOT TwoGadRequest *);
  323.                         END (* IF Langwort *);
  324.  
  325.                         ReadByteBlock (Datei, Langwort);
  326.  
  327.                         IF Langwort # CheckHunk.HEor THEN
  328.                            INCL (alvEvent, alvCheckSum);
  329.                            
  330.                            Copy (ReqText, FileName);
  331.                            Concat (ReqText, FalscheChecksummeFehler);
  332.  
  333.                            IF TwoGadRequest (ReqText, NIL) = 0 THEN
  334.                               returnVal := 21;
  335.                               Terminate ();
  336.  
  337.                            ELSE (* IF NOT TwoGadRequest *);
  338.                               (* EXIT (* LOOP *); *)
  339.                            END (* IF NOT TwoGadRequest *);
  340.                         END (* IF Langwort *);
  341.  
  342.                         ReadByteBlock (Datei, Langwort);
  343.  
  344.                         IF Langwort # CheckHunk.PLaenge THEN
  345.                            INCL (alvEvent, alvLength);
  346.                            
  347.                            Copy (ReqText, FileName);
  348.                            Concat (ReqText, FalscheLaengeFehler);
  349.  
  350.                            IF TwoGadRequest (ReqText, NIL) = 0 THEN
  351.                               returnVal := 21;
  352.                               Terminate ();
  353.  
  354.                            ELSE (* IF NOT TwoGadRequest *);
  355.                               (* EXIT (* LOOP *); *)
  356.                            END (* IF NOT TwoGadRequest *);
  357.                         END (* IF Langwort *);
  358.  
  359.                         ReadByteBlock (Datei, Langwort);
  360.  
  361.                         INC (CheckHunk.PLaenge, SIZE (CheckHunk) DIV 4);
  362.  
  363.                      ELSIF (Langwort = PIUS) AND (DieserHunk = 3) THEN
  364.  
  365.                         (* VIRUSCONTROL-Hunk *)
  366.                         
  367.                         INCL (alvEvent, alvVirusControl);
  368.  
  369.                         INC (CheckHunk.PLaenge, 6);
  370.  
  371.                         ReadByteBlock (Datei, Langwort);
  372.                         ReadByteBlock (Datei, Langwort);
  373.                         ReadByteBlock (Datei, Langwort);
  374.                         ReadByteBlock (Datei, Langwort);
  375.  
  376.                      ELSE (* unbekannter Hunk, der hier nichts zu suchen hat! *)
  377.                         INCL (alvEvent, alvMoreHunks);
  378.                         
  379.                         Copy (ReqText, FileName);
  380.                         Concat (ReqText, FalscherHunkFehler);
  381.  
  382.                         IF TwoGadRequest (ReqText, NIL) = 0 THEN
  383.                            returnVal := 21;
  384.                            Terminate ();
  385.  
  386.                         ELSE (* IF NOT TwoGadRequest *);
  387.                            (* EXIT (* LOOP *); *)
  388.                         END (* IF NOT TwoGadRequest *);
  389.                      END (* IF (Langwort = ALV) *);
  390.  
  391.                   ELSE (* IF Langwort = HunkName *)
  392.                      INCL (alvEvent, alvMoreHunks);
  393.                      
  394.                      IF Langwort = HunkCode THEN
  395.                            Copy (ReqText, FileName);
  396.                            Concat (ReqText, FalscherHunkFehler);
  397.  
  398.                         IF TwoGadRequest (ReqText, NIL) = 0 THEN
  399.                            returnVal := 21;
  400.                            Terminate ();
  401.  
  402.                         ELSE (* IF NOT TwoGadRequest *);
  403.                            (* EXIT (* LOOP *); *)
  404.                         END (* IF NOT TwoGadRequest *);
  405.                      END (* IF Langwort *);
  406.                   END (* IF Langwort = HunkName *);
  407.  
  408.                ELSE (* IF NOT Datei.eof *);
  409.                   IF NOT MeinHunkGelesen THEN
  410.                      INCL (alvEvent, alvNoHunk);
  411.                      
  412.                      Copy (ReqText, FileName);
  413.                      Concat (ReqText, KeinHunk);
  414.  
  415.                      IF TwoGadRequest (ReqText, NIL) # 0 THEN
  416.                         IF Jungfraeulich THEN
  417.                            WriteByteBlock (Datei, CheckHunk);
  418.                            EXIT (* LOOP *);
  419.                         END (* IF Jungfraeulich *);
  420.  
  421.                      ELSE (* IF TwoGadRequest *)
  422.                         returnVal := 21;
  423.                         Terminate ();
  424.                      END (* IF TwoGadRequest *);
  425.                   END (* IF NOT MeinHunkGelesen *);
  426.                END (* IF NOT Datei.eof *);
  427.  
  428.                IF Datei.eof THEN
  429.                   EXIT (* LOOP *);
  430.                END (* IF Datei.eof *);
  431.             END (* LOOP *);
  432.  
  433.          ELSE (* IF Langwort = HunkHeader *)
  434.             Error (ADR (UHTypText), ADR (KeALVText));
  435.          END (* IF Langwort *);
  436.  
  437.          Close (Datei);
  438.          Datei.file := NIL;
  439.       END (* IF Datei.res *);
  440.    END (* IF NOT *);
  441. END (* IF Laenge *);
  442.  
  443. (* --------------------------------------------------------------------- *)
  444.  
  445. CLOSE;
  446.  
  447. IF Datei.file # NIL THEN
  448.    Close (Datei);
  449.    Datei.file := NIL;
  450. END (* IF Datei.file *);
  451.  
  452. END AntiLinkVirus (* Implementations-Modul *).
  453.